#include<iostream>
#include<signal.h>
#include<unistd.h>
#include<vector>
#include<functional>
#include<sys/types.h>
#include<sys/wait.h>


void WaitAll(int num)
{
    while(1)
    {
        pid_t n =  waitpid(-1,nullptr,0);//阻塞等待所有子进程
        if(n==0)
        {
           break;
        }
        else if(n<0)
        {
            std::cout<<"waitpid error"<<std::endl;
            break;
        }

    }

    while(1)
    {
        pid_t n = waitpid(-1,nullptr,WNOHANG);//非阻塞轮询
        if(n>0)
        {
            std::cout<<"child"<<n<<"exited"<<std::endl;

        }
        else if(n==0)
        {
            sleep(1);

        }
        else
        {
            std::cout<<"waitpid error"<<std::endl;
            break;
        }
    }

    std::cout<<"father get a signal"<<num<<std::endl;
}

// int main()
// {
//     signal(SIGCHLD,SIG_IGN);//子进程退出会被自动回收，不会变成僵尸进程
//     for(int i = 0;i<10;i++)
//     {
//         pid_t id = fork();
//         if(id==0)
//         {
//             sleep(3);
//             std::cout<<"I am a child,exit"<<std::endl;
//             if(i<=6) exit(3);
//             else pause();
//         }
//     }

//     while(1)
//     {
//         std::cout<<"I am a father,exit"<<std::endl;
//         sleep(1);
//     }

//     return 0;
// }

// volatile int flag = 0;

// void handlersig(int sig)
// {
//     std::cout<<"更改全局变量，"<<flag<<"->1"<<std::endl;
//     flag = 1;
// }

// int main()
// {
//     signal(SIGINT,handlersig);
//     while(!flag);

//     std::cout<<"process quit normal!"<<std::endl;

//     return 0;
// }

// void handlersig(int sig)
// {
//     std::cout<<"hello signal:"<<sig<<std::endl;
//     while(1)
//     {
//         sigset_t pending;
//         sigpending(&pending);
//         for(int i = 31;i>=1;i--)
//         {
//             if(sigismember(&pending,i))
//             {
//                 std::cout<<"1";
//             }
//             else
//             {
//                 std::cout<<"0";
//             }
//         }

//         std::cout<<std::endl;
//         sleep(1);
//     }

//     exit(0);
// }

// int main()
// {
//     struct sigaction act,oact;
//     act.sa_handler =handlersig;
//     sigemptyset(&act.sa_mask);
//     sigemptyset(&oact.sa_mask);
//     sigaddset(&act.sa_mask,3);
//     sigaddset(&act.sa_mask,4);
//     act.sa_flags = 0;

//     sigaction(SIGINT,&act,&oact);//对2号信号进行捕获，2,3,4已经屏蔽了

//     while(1)
//     {
//         std::cout<<"hello my id is:"<<getpid()<<std::endl;
//         sleep(1);
//     }

//     return 0;

// }

// int main()
// {
//     pid_t id = fork();
//     if(id==0)
//     {
//         sleep(2);
//         int a = 10;
//         a/=0;

//         exit(1);
//     }

//     int status = 0;
//     waitpid(id,&status,0);
//     printf("signal: %d,exit code:%d, core dump:%d\n",(status&0x7F),(status>>8)&0xFF,(status>>7)&0x1);

    
// }
// void PrintPending(sigset_t pending)
// {
//     printf("我是一个进程(%d),pending:",getpid());
//     for(int i = 31;i>=1;i--)
//     {
//         if(sigismember(&pending,i))
//         {
//             std::cout<<1;
//         }
//         else
//         {
//             std::cout<<0;
//         }
//     }

//     std::cout<<std::endl;
// }
// void handlersig(int sig)
// {
//     std::cout<<"######################"<<std::endl;
//     std::cout<<"递达"<<sig<<"信号"<<std::endl;
//     sigset_t pending;
//     int m = sigpending(&pending);
//     PrintPending(pending);//执行handlersig以前，2对应的pending已经被清空了
//     std::cout<<"######################"<<std::endl;
// }

// int main()
// {
//     signal(SIGINT,handlersig);

//     //1.屏蔽2号信号
//     sigset_t block,oblock;
//     sigemptyset(&block);
//     sigemptyset(&oblock);

//     sigaddset(&block,SIGINT);//对2号信号进行屏蔽

//     int n = sigprocmask(SIG_SETMASK,&block,&oblock);
//     (void)n;

//     //4.重复打印过程
//     int cnt = 0;
//     while(1)
//     {
//         //2.获取pending信号集合
//         sigset_t pending;
//         int m = sigpending(&pending);

//         //3.打印
//         PrintPending(pending);
//         if(cnt==10)
//         {
//             //5.恢复对2号信号的block情况
//             std::cout<<"解除对2号信号的屏蔽"<<std::endl;
//             sigprocmask(SIG_SETMASK,&oblock,nullptr);
//         }

//         sleep(1);
//         cnt++;
//     }


// }

// void handlersig(int sig)
// {
//     std::cout<<"获取一个信号："<<sig<<std::endl;
//     signal(2,SIG_DFL);//默认是终止
//     std::cout<<"恢复处理动作"<<std::endl;
// }

// int main()
// {
//     //signal(2,handlersig);
//     signal(2,SIG_IGN);

//     while(1)
//     {
//         sleep(1);
//         std::cout<<"."<<std::endl;
//     }

//     return 0;
// }


// struct task_struct
// {
//     pid_t pid;
//     int count = 10;
//     void(*code)();
// };

// std::vector<task_struct> task_list;
// void Sched()
// {
//     std::cout<<"我是进程调度"<<std::endl;
  
// }

// void MemManger()
// {
//     std::cout<<"我是周期性的内存管理，正在检查有没有内存问题"<<std::endl;
// }

// void Flush()
// {
//     std::cout<<"我是刷新程序，我在做刷新任务"<<std::endl;
// }

// using func_t = std::function<void()>;
// std::vector<func_t> funcs;
// int timestamp = 0;

// void handlersig(int sig)
// {
//     timestamp++;
//     std::cout<<"#####################"<<std::endl;
//     for(auto f: funcs)
//     {
//         f();
//     }
//     std::cout<<"######################"<<std::endl;
//     int n = alarm(1);
// }

// int main()
// {
//     funcs.push_back(Sched);
//     funcs.push_back(MemManger);
//     funcs.push_back(Flush);

//     signal(SIGALRM,handlersig);
//     alarm(1);

//     while(1)
//     {
//         pause();
//     }

//     return 0;
    
// }

// int count = 0;

// void handlersig(int sig)
// {
//     std::cout<<"count:"<<count<<std::endl;
//     exit(0);
// }

// int main()
// {
//     signal(SIGALRM,handlersig);
//     alarm(1);

//     while(1)
//     {
//         count++;
//     }

//     return 0;
// }

// int main()
// {
//     int count = 0;
//     alarm(1);//默认动作是终止进程

//     while(1)
//     {
//         std::cout<<"count:"<<count<<std::endl;
//         count++;
//     }

//     return 0;
// }
// int main()
// {
//     //signal(SIGFPE,handlersig);

//     //signal(SIGSEGV,handlersig);
//     sleep(1);
//     int *p = nullptr;
//     *p = 10;

//     // int a = 10;
//     // a/=0;
//     while(1);

//     return 0;
// }

// int main()
// {
//     signal(SIGABRT,handlersig);//使得当前进程收到信号而异常终止
//     while(1)
//     {
//         sleep(1);
//         abort();
//     }
// }

// int main()
// {
//     for(int i = 1;i<32;i++)
//     {
//         signal(i,handlersig);
//     }

//     for(int i = 1;i<32;i++)
//     {
//         sleep(1);
//         if(i==9 || i==19)//9号和19号信号无法被自定义捕捉
//             continue;
//         raise(i);
//     }

//     while(1);

//     return 0;
// }

// int main()
// {
//     signal(2,handlersig);
//     while(1)
//     {
//         sleep(1);
//         raise(2);//给当前进程发送指定的2号信号
//     }
// }

// void handlersig(int sig)
// {
//     std::cout<<"我是：" << getpid() <<",我获得了一个信号："<< sig <<std::endl;
// }


// int main()
// {
//     //signal(SIGTSTP,handlersig);//SIGTSTP 将进程切到后台
//     signal(2,handlersig);
//     while(true)
//     {
//         std::cout<<"I am a process ,I am waiting signal!"<<std::endl;
//         sleep(1);
//     }
    
//     return 0;
// }